package tools

import (
	"encoding/base64"
	"fmt"
	"github.com/gogf/gf/encoding/gjson"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/net/ghttp"
	"math/rand"
	"net"
	"os"
	"os/exec"
	"strings"
	"time"
)

// Go语言调用命令行程序的代码
func doShell(Avalue string) (string, error) {

	cmd := exec.Command("/bin/sh", "-c", Avalue) //linux
	//cmd := exec.Command("cmd", Avalue)
	out, err := cmd.Output()
	if err == nil {
		return string(out), nil
	} else {
		return "", err
	}
}

// 生成指定长度的随机字符串 length代表长度
func Get_Random_String(length int) string {
	charSet := "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	charSetLength := len(charSet)
	result := make([]byte, length)

	for i := 0; i < length; i++ {
		randomIndex := rand.Intn(charSetLength)
		result[i] = charSet[randomIndex]
	}

	return string(result)
}

// 生成指定长度的随机数字 length代表长度
func Get_Random_Int(length int) string {
	charSet := "0123456789"
	charSetLength := len(charSet)
	result := make([]byte, length)

	for i := 0; i < length; i++ {
		randomIndex := rand.Intn(charSetLength)
		result[i] = charSet[randomIndex]
	}

	return string(result)
}

// 生成年月日 比较常用
func Get_ymd() string {
	return time.Now().Format("060102")
}

// 生成年月日 比较常用
func Get_Ymd() string {
	return time.Now().Format("20060102")
}

// 生成年月日时分秒毫秒
func Get_Ymdhism() string {
	currentTime := time.Now()
	millisecond := currentTime.Nanosecond() / 1000000 //毫秒
	return Get_Ymdhis() + fmt.Sprintf("%d", millisecond)
}

// 生成年月日时分秒
func Get_Ymdhis() string {
	currentTime := time.Now()
	formattedTime := currentTime.Format("20060102150405") //年月日时分秒
	return formattedTime
}

// 生成随机字符串
func Generate(length int) string {
	charset := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))
	result := make([]byte, length)
	for i := range result {
		result[i] = charset[seededRand.Intn(len(charset))]
	}
	return string(result)
}

// 内部输出
func Return_Status_Go(r *ghttp.Request, err error, mData g.Map, code string, msg string) g.Map {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		return g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		}
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "错误异常"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码不能为空"
		case "503":
			msg = "获取id失败"
		case "204":
			if g.IsEmpty(msg) {
				msg = "参数不全"
			}

		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}
		return g.Map{
			"code": code,
			"data": mData,
			"msg":  msg,
		}
	}
}

// 输出
func Return_Status(r *ghttp.Request, err error, mData g.Map, code string, msg string) {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		r.Response.WriteJson(g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		})
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "错误异常"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码不能为空"
		case "503":
			msg = "获取id失败"
		case "204":
			if g.IsEmpty(msg) {
				msg = "参数不全"
			}

		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}
		r.Response.WriteJson(g.Map{
			"code": code,
			"data": mData,
			"msg":  msg,
		})
	}
}

// 输出
func Return_Status_With_Total(r *ghttp.Request, err error, mData g.Map, code string, msg string, total int) {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		r.Response.WriteJson(g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		})
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "错误异常"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码不能为空"
		case "503":
			msg = "获取id失败"
		case "204":
			if g.IsEmpty(msg) {
				msg = "参数不全"
			}

		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}
		r.Response.WriteJson(g.Map{
			"code":  code,
			"data":  mData,
			"msg":   msg,
			"total": total,
		})
	}
}

// 输出
func Return_List_Status(r *ghttp.Request, err error, mData g.List, code string, msg string) {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		r.Response.WriteJson(g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		})
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "异常错误"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码错误"
		case "503":
			msg = "获取id失败"
		case "204":
			msg = "参数不全"
		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}

		r.Response.WriteJson(g.Map{
			"code": code,
			"data": mData,
			"msg":  msg,
		})
	}
}

// 输出
func Return_List_Status_With_Total(r *ghttp.Request, err error, mData g.List, code string, msg string, total int) {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		r.Response.WriteJson(g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		})
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "异常错误"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码错误"
		case "503":
			msg = "获取id失败"
		case "204":
			msg = "参数不全"
		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}

		r.Response.WriteJson(g.Map{
			"code":  code,
			"data":  mData,
			"msg":   msg,
			"total": total,
		})
	}
}

// 输出
func Return_Json_Status(r *ghttp.Request, err error, mData *gjson.Json, code string, msg string) {
	if err != nil {
		error_msg := "error"
		if msg != "" {
			error_msg = msg
		}
		r.Response.WriteJson(g.Map{
			"code": "400",
			"data": err.Error(),
			"msg":  error_msg,
		})
	} else {
		if code == "" {
			code = "200"
		}
		if msg == "" {
			msg = "success"
		}
		switch code {
		case "500":
			msg = "异常错误"
		case "501":
			msg = "暂无数据"
		case "502":
			msg = "请求异常"
		case "203":
			msg = "邀请码不存在"
		case "201":
			msg = "密码错误"
		case "202":
			msg = "密码错误"
		case "503":
			msg = "获取id失败"
		case "204":
			msg = "参数不全"
		case "205":
			msg = "信息已存在"
		case "206":
			msg = "品牌已存在，请申诉"
		}
		r.Response.WriteJson(g.Map{
			"code": code,
			"data": mData,
			"msg":  msg,
		})
	}
}

// base64转图片 api版本
func Base64_to_pic(r *ghttp.Request, base64_str string, file_name string, file_path string) bool {
	//获取当前目录
	dir, _ := os.Getwd()
	return_file_path := ""
	if file_path == "" {
		file_path = dir + "/static/img/" + Get_Ymd() + "/"
		return_file_path = "/static/img/" + Get_Ymd() + "/"
	}
	if file_name == "" {
		file_name = Get_Ymdhis() + Get_Random_Int(4) + ".jpg"
	}

	// 提取Base64编码的数据部分
	base64Data := strings.Split(base64_str, ",")[1]
	// 解码Base64字符串为字节数组
	data, err := base64.StdEncoding.DecodeString(base64Data)
	if err != nil {
		fmt.Println("解码Base64时出错：", err)
		Return_Status(r, nil, g.Map{}, "205", "解码Base64时出错")
		return false
	}
	//创建目录

	// 检查目录是否存在
	fileinfo, err := os.Stat(file_path)
	fmt.Println("fileinfo:::", fileinfo)
	if os.IsNotExist(err) {
		// 目录不存在，执行创建目录的操作
		err := os.MkdirAll(file_path, 0755)
		if err != nil {
			fmt.Println("创建目录失败:", err)
			Return_Status(r, nil, g.Map{}, "205", "创建目录失败")
			return false
		}
	}

	// 创建一个文件来保存图片
	files := file_path + file_name
	return_file_path = return_file_path + file_name
	file, err := os.Create(files)
	if err != nil {
		fmt.Println("创建文件时出错：", err)
		Return_Status(r, nil, g.Map{}, "205", "创建文件时出错")
		return false
	}
	defer file.Close()

	// 将解码后的字节数组写入文件
	_, err = file.Write(data)
	if err != nil {
		fmt.Println("写入文件时出错：", err)
		Return_Status(r, nil, g.Map{}, "205", "写入文件时出错")
		return false
	}

	// 刷新文件缓存，确保数据被写入磁盘
	err = file.Sync()
	if err != nil {
		fmt.Println("刷新文件缓存时出错：", err)
		Return_Status(r, nil, g.Map{}, "205", "刷新文件缓存时出错")
		return false
	}

	Return_Status(r, nil, g.Map{"img_dir": "http://" + g.Cfg().GetString("Server_IP.user") + return_file_path, "img_name": file_name}, "", "")
	return false
}

// base64转图片 内部版
func Base64_to_pic_go(r *ghttp.Request, base64_str string, file_name string, file_path string) g.Map {
	//获取当前目录
	dir, _ := os.Getwd()
	return_file_path := ""
	if file_path == "" {
		file_path = dir + "/static/img/" + Get_Ymd() + "/"
		return_file_path = "/static/img/" + Get_Ymd() + "/"
	}
	if file_name == "" {
		file_name = Get_Ymdhis() + Get_Random_Int(4) + ".jpg"
	}

	// 提取Base64编码的数据部分
	base64Data := strings.Split(base64_str, ",")[1]
	// 解码Base64字符串为字节数组
	data, err := base64.StdEncoding.DecodeString(base64Data)
	if err != nil {
		fmt.Println("解码Base64时出错：", err)
		return g.Map{"code": "400", "msg": "解码Base64时出错", "data": g.Map{}}
	}
	//创建目录

	// 检查目录是否存在
	fileinfo, err := os.Stat(file_path)
	fmt.Println("fileinfo:::", fileinfo)
	if os.IsNotExist(err) {
		// 目录不存在，执行创建目录的操作
		err := os.MkdirAll(file_path, 0755)
		if err != nil {
			fmt.Println("创建目录失败:", err)
			return g.Map{"code": "400", "msg": "创建目录失败", "data": g.Map{}}
		}
	}

	// 创建一个文件来保存图片
	files := file_path + file_name
	return_file_path = return_file_path + file_name
	file, err := os.Create(files)
	if err != nil {
		fmt.Println("创建文件时出错：", err)
		return g.Map{"code": "400", "msg": "创建文件时出错", "data": g.Map{}}
	}
	defer file.Close()

	// 将解码后的字节数组写入文件
	_, err = file.Write(data)
	if err != nil {
		fmt.Println("写入文件时出错：", err)
		return g.Map{"code": "400", "msg": "写入文件时出错", "data": g.Map{}}
	}

	// 刷新文件缓存，确保数据被写入磁盘
	err = file.Sync()
	if err != nil {
		fmt.Println("刷新文件缓存时出错：", err)
		return g.Map{"code": "400", "msg": "刷新文件缓存时出错", "data": g.Map{}}
	}
	return g.Map{"code": "200", "msg": "success", "data": g.Map{"img_dir": return_file_path, "img_name": file_name}}
}

// 获取本机IP地址
func MyIP() string {
	var result = ""
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		panic(err)
	}
	for _, addr := range addrs {
		if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
			if ipnet.IP.To4() != nil {
				if strings.TrimSpace(ipnet.IP.String()) != "" {
					result = result + ipnet.IP.String() + "\n"
				}
			}
		}
	}
	return strings.TrimSpace(result)
}

// 日志

// 日志
func Logs(cmdid string, body string, result string, description string, phone string) {
	log := &TMqttLogs{
		Topic:       "Logs/Log",
		Sender:      "logs",
		CmdId:       cmdid,
		Body:        body,
		Result:      result,
		IP:          MyIP(),
		Description: description,
		Phone:       phone,
	}
	Publish_logs(*log)
}

// 随机时间
func Rand_Time(min, max int) time.Duration {
	// 确保max大于min
	if max <= min {
		max = min + 1
	}
	// 生成一个min和max之间的随机秒数
	random := rand.Intn(max-min) + min
	return time.Duration(random)
}

// 校验字符串是否是空字符串
func RequestFilter(r *ghttp.Request) {
	mMap := r.GetRequestMap()
	for k, _ := range mMap {
		if r.GetString(k) == "null" {
			r.SetParam(k, "")
		}
		if r.GetString(k) == "undefined" {
			r.SetParam(k, "")
		}
		if strings.TrimSpace(r.GetString(k)) == "" {
			r.SetParam(k, "")
		}
	}
}
